/**
 * 语音识别服务
 * 处理音频文件上传和语音转文字功能
 */

/**
 * 文本聊天接口结果
 */
export interface TextChatResult {
  success: boolean
  reply?: string
  audioUrl?: string // AI回复的MP3音频地址
  error?: string
}

/**
 * SSE流式回调函数
 */
export type StreamCallback = (chunk: string, isComplete: boolean) => void

/**
 * 调用文本聊天接口（SSE流式输出）
 * @param message 用户消息
 * @param role 角色名称
 * @param onStream 流式回调函数
 * @returns 聊天结果
 */
export const callTextChatAPI = async (
  message: string, 
  role: string = '助手',
  onStream?: StreamCallback
): Promise<TextChatResult> => {
  try {
    // 构建 GET 请求参数
    const params = new URLSearchParams({
      text: message,
      role: role
    })
    
    const url = `/TextChat?${params.toString()}`
    console.log('请求URL:', url)
    
    // 使用 EventSource 处理 SSE 流（GET请求）
    return new Promise((resolve, reject) => {
      const eventSource = new EventSource(url)
      let fullResponse = '' // 存储完整的响应内容
      let hasReceivedData = false
      
      // 设置超时处理
      const timeout = setTimeout(() => {
        console.log('SSE连接超时')
        eventSource.close()
        if (!hasReceivedData) {
          reject(new Error('请求超时'))
        }
      }, 30000) // 30秒超时
      
      // 监听消息事件
      eventSource.onmessage = (event) => {
        console.log('收到SSE原始数据:', event.data)
        hasReceivedData = true
        
        // 清理数据，过滤控制字符
        const rawData = event.data
        
        // 过滤 SSE 控制字符
        let cleanData = rawData
        
        // 移除各种控制字符和前缀
        const filterPatterns = [
          /^data:\s*/,    // data: 前缀
          /^message\s*/,  // message 前缀
          /^nt:\s*/,      // nt: 前缀
          /^ta:\s*/,      // ta: 前缀
          /^ata:\s*/,     // ata: 前缀
          /^ent:\s*/,     // ent: 前缀
          /^vent:\s*/,    // vent: 前缀
          /^ssage\s*/,    // ssage 前缀
          /^agedata\s*/,  // agedata 前缀
          /^gedata\s*/    // gedata 前缀
        ]
        
        filterPatterns.forEach(pattern => {
          cleanData = cleanData.replace(pattern, '')
        })
        
        console.log('清理后的数据:', cleanData)
        
        // 检查结束标识
        if (cleanData === 'COMPLETE' || cleanData === '[DONE]' || cleanData.trim() === '') {
          console.log('收到结束标识，关闭SSE连接')
          clearTimeout(timeout)
          eventSource.close()
          
          // 通知流式完成
          onStream?.(fullResponse, true)
          
          resolve({
            success: true,
            reply: fullResponse,
            audioUrl: undefined
          })
          return
        }
        
        // 如果有有效内容，处理增量数据
        if (cleanData && cleanData.trim() !== '') {
          // 使用独立变量存储本次新增内容（避免内容重复）
          const incrementalData = cleanData
          fullResponse += incrementalData
          
          console.log('本次增量内容:', incrementalData)
          console.log('当前完整内容:', fullResponse)
          
          // 只将增量数据传递给回调函数
          onStream?.(incrementalData, false)
        }
      }
      
      // 监听错误事件
      eventSource.onerror = (error) => {
        console.error('SSE连接错误:', error)
        clearTimeout(timeout)
        eventSource.close()
        
        if (hasReceivedData && fullResponse) {
          // 如果已经收到了一些数据，返回已有的内容
          resolve({
            success: true,
            reply: fullResponse,
            audioUrl: undefined
          })
        } else {
          reject(new Error('SSE连接失败'))
        }
      }
      
      // 监听连接打开事件
      eventSource.onopen = () => {
        console.log('SSE连接已建立')
      }
    })
    
  } catch (error) {
    console.error('文本聊天API调用失败:', error)
    return {
      success: false,
      error: error instanceof Error ? error.message : '未知错误'
    }
  }
}

export interface SpeechRecognitionResult {
  success: boolean
  text?: string
  audioUrl?: string // AI回复的MP3音频地址
  error?: string
}

export interface UploadProgress {
  loaded: number
  total: number
  percentage: number
}

/**
 * 上传音频文件到后端进行语音识别
 * @param audioBlob MP3音频文件Blob
 * @param onProgress 上传进度回调
 * @returns 语音识别结果
 */
export const uploadAudioForRecognition = async (
  audioBlob: Blob,
  onProgress?: (progress: UploadProgress) => void,
  role: string = '吕布'
): Promise<SpeechRecognitionResult> => {
  try {
    // 创建FormData对象
    const formData = new FormData()
    
    // 根据音频类型决定文件名和扩展名
    let fileName = 'recording.mp3' // 默认使用MP3格式
    if (audioBlob.type.includes('mp3')) {
      fileName = 'recording.mp3'
    } else if (audioBlob.type.includes('wav')) {
      fileName = 'recording.wav'
    } else if (audioBlob.type.includes('mp4')) {
      fileName = 'recording.mp4'
    } else if (audioBlob.type.includes('webm')) {
      fileName = 'recording.webm'
    } else if (audioBlob.type.includes('ogg')) {
      fileName = 'recording.ogg'
    }
    
    formData.append('file', audioBlob, fileName)
    formData.append('role', role) // 添加角色参数，动态传递
    
    console.log('📤 上传参数:', {
      fileName: fileName,
      role: role,
      audioSize: (audioBlob.size / 1024).toFixed(2) + 'KB'
    })
    
    // 创建XMLHttpRequest以支持进度回调
    return new Promise((resolve, reject) => {
      const xhr = new XMLHttpRequest()
      
      // 监听上传进度
      if (onProgress) {
        xhr.upload.addEventListener('progress', (event) => {
          if (event.lengthComputable) {
            const progress: UploadProgress = {
              loaded: event.loaded,
              total: event.total,
              percentage: Math.round((event.loaded / event.total) * 100)
            }
            onProgress(progress)
          }
        })
      }
      
      // 监听请求完成
      xhr.addEventListener('load', () => {
        if (xhr.status === 200) {
          try {
            // 如果后端返回JSON格式
            let responseText
            let audioUrl
            try {
              const response = JSON.parse(xhr.responseText)
              console.log('语音识别后端JSON响应:', response)
              responseText = response.text || response.result || response.data || response.message
              // 提取音频URL（支持多种字段名）
              audioUrl = response.audioUrl || response.audio_url || response.mp3Url || response.mp3_url || response.audioPath || response.audio_path
              
              console.log('解析的语音识别文本:', responseText)
              console.log('解析的音频URL:', audioUrl)
              
              if (audioUrl) {
                console.log('检测到后端返回的音频URL:', audioUrl)
              }
            } catch {
              // 如果不是JSON格式，可能是直接返回的文本或MP3地址
              const rawResponse = xhr.responseText.trim()
              console.log('非JSON格式响应:', rawResponse)
              
              // 判断是否是MP3文件地址
              if (rawResponse.includes('.mp3') || rawResponse.startsWith('http')) {
                // 如果是文件地址，作为音频URL处理
                audioUrl = rawResponse
                responseText = '语音识别成功' // 提供默认文本
                console.log('检测到MP3地址响应:', audioUrl)
              } else {
                // 否则作为识别文本处理
                responseText = rawResponse
                console.log('检测到文本响应:', responseText)
              }
            }
            resolve({
              success: true,
              text: responseText || '语音识别成功',
              audioUrl: audioUrl
            })
          } catch (error) {
            resolve({
              success: false,
              error: '响应解析失败'
            })
          }
        } else {
          resolve({
            success: false,
            error: `请求失败: ${xhr.status} ${xhr.statusText}`
          })
        }
      })
      
      // 监听错误
      xhr.addEventListener('error', () => {
        resolve({
          success: false,
          error: '网络错误，请检查网络连接'
        })
      })
      
      // 监听超时
      xhr.addEventListener('timeout', () => {
        resolve({
          success: false,
          error: '请求超时，请重试'
        })
      })
      
      // 配置请求
      xhr.timeout = 30000 // 30秒超时
      
      // 使用新的语音接口地址
      const apiUrl = '/AudioChat'
      
      xhr.open('POST', apiUrl)
      xhr.send(formData)
    })
    
  } catch (error) {
    console.error('音频上传失败:', error)
    return {
      success: false,
      error: error instanceof Error ? error.message : '未知错误'
    }
  }
}

/**
 * 模拟语音识别（用于开发测试）
 * @param audioBlob 音频文件
 * @returns 模拟的识别结果
 */
export const mockSpeechRecognition = async (audioBlob: Blob): Promise<SpeechRecognitionResult> => {
  // 模拟网络延迟
  await new Promise(resolve => setTimeout(resolve, 1000 + Math.random() * 2000))
  
  // 模拟识别结果
  const mockTexts = [
    '你好，我想了解一下产品的功能',
    '请帮我分析一下这个问题',
    '今天天气怎么样？',
    '能帮我写一段代码吗？',
    '谢谢你的帮助'
  ]
  
  const randomText = mockTexts[Math.floor(Math.random() * mockTexts.length)]
  
  // 模拟偶尔失败的情况
  if (Math.random() < 0.1) {
    return {
      success: false,
      error: '语音识别失败，请重试'
    }
  }
  
  return {
    success: true,
    text: randomText
  }
}

/**
 * 检查音频文件格式和大小
 * @param audioBlob 音频文件
 * @returns 检查结果
 */
export const validateAudioFile = (audioBlob: Blob): { valid: boolean; error?: string } => {
  // 检查文件大小（限制为10MB）
  const maxSize = 10 * 1024 * 1024
  if (audioBlob.size > maxSize) {
    return {
      valid: false,
      error: '音频文件过大，请录制较短的音频'
    }
  }
  
  // 检查文件大小（最小100字节）
  if (audioBlob.size < 100) {
    return {
      valid: false,
      error: '音频文件过小，请重新录制'
    }
  }
  
  return { valid: true }
}